home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / gnu / gnushogi.lha / gnushogi-1.1 / src / size_test.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-16  |  7.1 KB  |  277 lines
  1. /*
  2.  * main.c - C source for GNU SHOGI based on GNU CHESS
  3.  *
  4.  * Copyright (c) 1988,1989,1990 John Stanback (GNU Chess)
  5.  * Copyright (c) 1992 Free Software Foundation 
  6.  * Copyright (c) 1993 Matthias Mutz (GNU Shogi)
  7.  *
  8.  * This file is part of GNU SHOGI.
  9.  *
  10.  * GNU Shogi is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 1, or (at your option)
  13.  * any later version.
  14.  *
  15.  * GNU Shogi is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with GNU Shogi; see the file COPYING.  If not, write to
  22.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  24.  
  25.  
  26. #if !defined NO_MAIN
  27.  
  28. #include "version.h"
  29. #include "gnushogi.h"
  30.  
  31. #endif
  32.  
  33. #include <signal.h>
  34.  
  35. #if defined THINK_C
  36. #include <console.h>
  37. #include <time.h>
  38. #endif
  39.  
  40. #if !defined K32SEGMENTS
  41. #include "main_data1.c"
  42. #include "main_data2.c"
  43. #endif
  44.  
  45.  
  46. #if defined HASGETTIMEOFDAY && defined THINK_C
  47.  
  48. #define USEC_PER_CLOCK (1000000 / CLOCKS_PER_SEC)
  49.  
  50. int gettimeofday(struct timeval *tp, void *tzp)
  51. { 
  52.    long clock_count = (long)clock();
  53.    tp->tv_sec = clock_count / CLOCKS_PER_SEC;
  54.    tp->tv_usec = (clock_count % CLOCKS_PER_SEC) * USEC_PER_CLOCK;
  55.    return(0);
  56. }
  57.  
  58. #endif
  59.  
  60. /*
  61.  * In a networked enviroment gnuchess might be compiled on different hosts
  62.  * with different random number generators, that is not acceptable if they
  63.  * are going to share the same transposition table.
  64.  */
  65. unsigned long int next = 1;
  66.  
  67. unsigned int
  68. urand (void)
  69. {
  70.   next *= 1103515245;
  71.   next += 12345;
  72.   return ((unsigned int) (next >> 16) & 0xFFFF);
  73. }
  74.  
  75. void
  76. gsrand (unsigned int seed)
  77. {
  78.   next = seed;
  79. }
  80.  
  81. #if ttblsz
  82. struct hashentry huge *ttable[2];
  83. unsigned int ttblsize;
  84. #endif
  85. #ifdef BINBOOK
  86. extern char *binbookfile;
  87. #endif
  88. extern char *bookfile;
  89.  
  90. unsigned long hashkey, hashbd;
  91. struct hashval hashcode[2][NO_PIECES][NO_SQUARES+(2*NO_PIECES)];
  92.  
  93. char savefile[128] = "";
  94. char listfile[128] = "";
  95.  
  96. #if defined HISTORY
  97. unsigned short *history;
  98. #endif
  99.  
  100. short rpthash[2][256];
  101. short TrPnt[MAXDEPTH];
  102. small_short PieceList[2][NO_SQUARES];
  103. small_short PawnCnt[2][NO_COLS];
  104. small_short Captured[2][NO_PIECES];
  105. small_short Mvboard[NO_SQUARES];
  106. short svalue[NO_SQUARES];
  107. struct flags flag;
  108.  
  109. short opponent, computer, WAwindow, WBwindow, BAwindow, BBwindow, dither,
  110.   BADscore;
  111. long ResponseTime, ExtraTime, MaxResponseTime, et, et0, time0, ft;
  112. long GenCnt, NodeCnt, ETnodes, EvalNodes, HashCnt, HashAdd, FHashCnt, FHashAdd,
  113.   HashCol, THashCol, filesz, hashmask, hashbase;
  114. long replus, reminus;
  115. short HashDepth = HASHDEPTH, HashMoveLimit = HASHMOVELIMIT;
  116. short player, xwndw;
  117. /*unsigned*/ short rehash; /* -1 is used as a flag --tpm */
  118. short Sdepth, Game50, MaxSearchDepth;
  119. short GameCnt = 0;
  120. short contempt;
  121. int Book;
  122. struct TimeControlRec TimeControl;
  123. int TCadd = 0;
  124. short TCflag, TCmoves, TCminutes, TCseconds, OperatorTime;
  125. short XCmoves[3], XCminutes[3], XCseconds[3], XC, XCmore;
  126. const short otherside[3] =
  127. {white, black, neutral};
  128. unsigned short hint;
  129. short int TOflag;        /* force search re-init if we backup search */
  130.  
  131. unsigned short killr0[MAXDEPTH], killr1[MAXDEPTH];
  132. unsigned short killr2[MAXDEPTH], killr3[MAXDEPTH];
  133. unsigned short PV, SwagHt, Swag0, Swag1, Swag2, Swag3, Swag4, sidebit;
  134.  
  135. const small_short sweep[NO_PIECES] =
  136. {false, false, true,  false, false, false, true, true,
  137.         false, false, false, false, true,  true,  false };
  138. small_short HasPiece[2][NO_PIECES]; 
  139. const short kingP[3] =
  140. {4, 76, 0};
  141. const short value[NO_PIECES] =
  142. {0, valueP,  valueL,  valueN,  valueS,  valueG,  valueB,  valueR,
  143.     valuePp, valueLp, valueNp, valueSp, valueBp, valueRp, valueK}; 
  144. const small_short relative_value[NO_PIECES] =
  145. {0, 1,       3,       4,       7,       9,       10,      12, 
  146.     2,       5,       6,       8,       11,      13,      14};
  147. const long control[NO_PIECES] =
  148. {0, ctlP, ctlL, ctlN, ctlS, ctlG, ctlB, ctlR,
  149.     ctlPp, ctlLp, ctlNp, ctlSp, ctlBp, ctlRp, ctlK };
  150.  
  151. short stage, stage2;
  152.  
  153. FILE *hashfile;
  154.  
  155. unsigned int starttime;
  156. short int ahead = true, hash = true;
  157.  
  158.  
  159.  
  160. #if defined XSHOGI
  161. void
  162. TerminateChess (int sig)
  163. {
  164.   ExitChess ();
  165. }
  166.  
  167. #endif
  168.  
  169.  
  170.  
  171. int timeopp[MINGAMEIN], timecomp[MINGAMEIN];
  172. int compptr, oppptr;
  173. inline void
  174. TimeCalc ()
  175. {
  176. /* adjust number of moves remaining in gamein games */
  177.   int increment = 0;
  178.   int topsum = 0;
  179.   int tcompsum = 0;
  180.   int me,him;
  181.   int i;
  182. /* dont do anything til you have enough numbers */
  183.   if (GameCnt < (MINGAMEIN * 2)) return;
  184. /* calculate average time in sec for last MINGAMEIN moves */
  185.   for (i = 0; i < MINGAMEIN; i++)
  186.     {
  187.       tcompsum += timecomp[i];
  188.       topsum += timeopp[i];
  189.     }
  190.   topsum /= (100 * MINGAMEIN);
  191.   tcompsum /= (100 * MINGAMEIN);
  192. /* if I have less time than opponent add another move */
  193.     me = TimeControl.clock[computer]/100; 
  194.     him = TimeControl.clock[opponent]/100;
  195.     if(me < him) increment += 2;
  196.     if((him - me) > 60 || (me<him && me < 120))increment++;
  197. /* if I am losing more time with each move add another */
  198.   /*if ( !((me - him) > 60) && tcompsum > topsum) increment++;*/
  199.   if ( tcompsum > topsum) increment +=2;
  200. /* but dont let moves go below MINMOVES */
  201.   else if (TimeControl.moves[computer] < MINMOVES && !increment) increment++;
  202. /* if I am doing really well use more time per move */
  203.   else if (me > him && tcompsum < topsum) increment = -1;
  204.   TimeControl.moves[computer] += increment;
  205. }
  206.  
  207.  
  208.  
  209.  
  210. #if !defined NO_MAIN
  211.  
  212.  
  213. /* hmm.... shouldn`t main be moved to the interface routines */
  214. int
  215. main (int argc, char **argv)
  216. {
  217.   long l;
  218.   int  n;
  219.  
  220. #ifdef THINK_C
  221.   console_options.ncols = 100;
  222.   cshow(stdout);
  223. #endif
  224.  
  225.   l = (long)sizeof(struct hashentry);
  226.   n = (int)((l * (ttblsz + rehash) * 2) / 1000);
  227.   printf("ttable:\t\t%d\tkByte\t[hashentry:%ld * (ttblsz:%d + rehash:%d) * 2]\n",
  228.      n,l,ttblsz,rehash);
  229.  
  230. #if defined CACHE
  231.   l = (long)sizeof(struct etable);
  232.   n = (int)((l * (size_t)ETABLE) / 1000);
  233. #else
  234.   l = n = 0;
  235. #endif
  236.   printf("etab:\t\t%d\tkByte\t[etable:%ld ETABLE:%d]\n",n,l,ETABLE);
  237.  
  238.   l = (long)sizeof(struct leaf);
  239.   n = (int)(sizeof(Tree) / 1000);
  240.   printf("Tree:\t\t%d\tkByte\t[leaf:%ld * TREE:%d]\n",n,l,TREE);
  241.  
  242. #if defined HISTORY
  243.   n = (int)(sizeof_history / 1000);
  244. #else
  245.   n = 0;
  246. #endif
  247.   printf("history:\t%d\tkByte\n",n);
  248.  
  249.   l = (long)sizeof(next_array);
  250.   n = (int)((l * NO_PTYPE_PIECES) / 1000);
  251.   printf("nextpos:\t%d\tkByte\t[next_array:%ld * NO_PTYPE_PIECES:%d]\n",
  252.     n,l,NO_PTYPE_PIECES);
  253.  
  254.   l = (long)sizeof(next_array);
  255.   n = (int)((l * NO_PTYPE_PIECES) / 1000);
  256.   printf("nextdir:\t%d\tkByte\t[next_array:%ld * NO_PTYPE_PIECES:%d]\n",
  257.     n,l,NO_PTYPE_PIECES);
  258.  
  259.   n = (int)(sizeof(distdata) / 1000);
  260.   printf("distdata:\t%d\tkByte\n",n);
  261.  
  262.   l = (long)sizeof(next_array);
  263.   n = (int)((l * NO_PTYPE_PIECES) / 1000);
  264.   printf("ptype_distdata:\t%d\tkByte\t[next_array:%ld * NO_PTYPE_PIECES:%d]\n",
  265.     n,l,NO_PTYPE_PIECES);
  266.  
  267.   l = (long)sizeof(hashcode);
  268.   n = (int)(l / 1000);
  269.   printf("hashcode:\t%d\tkByte\t[hashval:%ld]\n",
  270.     n,(long)sizeof(struct hashval));
  271.  
  272. }
  273.  
  274.  
  275. #endif /* NO_MAIN */
  276.  
  277.